<html>

<head>
	<meta http-equiv="content-type" content="text/html; charset=utf-8" />
	<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
	<title>iscs_FrontEnd:javascript-style-guide</title>
	<link href="toc/style/github-bf51422f4bb36427d391e4b75a1daa083c2d840e.css" media="all" rel="stylesheet" type="text/css" />
	<link href="toc/style/github2-d731afd4f624c99a4b19ad69f3083cd6d02b81d5.css" media="all" rel="stylesheet" type="text/css" />
	<!--<link href="toc/css/zTreeStyle/zTreeStyle.css" media="all" rel="stylesheet" type="text/css" />-->
	<link href="toc/css/metroStyle/metroStyle.css" media="all" rel="stylesheet" type="text/css" />
	<link href="toc/css/themes/github-v2.min.css" media="all" rel="stylesheet" type="text/css" />
	<link type="text/css" rel="stylesheet" href="assets/bootstrap/css/bootstrap.css">
	<link type="text/css" rel="stylesheet" href="indexcss/docs.css">
	<style>
		table {
			border: 1px solid #ccc;
			border-left: 0;
			width: 100%;
			font-size: 14px;
		}
		
		tbody,
		thead,
		tr {
			width: 100%;
		}
		
		tr th {
			border: 1px solid #ccc;
			border-right: 0;
			background: #FF6537;
			color: #fff;
			height: 40px;
			padding: 5px 10px;
			font-size: 14px;
		}
		
		tr td {
			text-align: left;
			padding: 5px 10px;
			border: 1px solid #ccc;
			border-right: 0;
		}
		
		tr:nth-child(odd) {
			background: #f4f4f4;
		}
		
		table tr:hover td {
			background: #ccc;
		}
		
		.markdown-body h1 {
			font-size: 20px;
			color: #FF6537;
		}
		
		.markdown-body h2 {
			font-size: 18px;
		}
		
		.markdown-body h3 {
			font-size: 16px;
		}
		
		#header {
			width: 100%;
			height: 25px;
			background-color: #FF6537;
			position: fixed;
			top: 0;
		}
	</style>

</head>

<body>
	
	<div>
		<div style='width:25%;'>
			<ul id="tree" class="ztree" style='width:100%;'>

			</ul>
		</div>
		<div id='readme' style='width:70%;margin-left:20%;'>
			<article class='markdown-body'>
				<p><strong>JavaScript编码规范</strong></p>
<h1 id="-">前言</h1>
<p>JavaScript 在百度一直有着广泛的应用，特别是在浏览器端的行为管理。本文档的目标是使 JavaScript 代码风格保持一致，容易被理解和被维护。</p>
<p>虽然本文档是针对 JavaScript 设计的，但是在使用各种 JavaScript 的预编译语言时(如 TypeScript 等)时，适用的部分也应尽量遵循本文档的约定。</p>
<h1 id="-">代码风格</h1>
<h2 id="-">文件</h2>
<p>[建议] JavaScript 文件使用无 <code>BOM</code> 的 <code>UTF-8</code> 编码。</p>
<p>解释：</p>
<p>UTF-8 编码具有更广泛的适应性。BOM 在使用程序或工具处理文件时可能造成不必要的干扰。</p>
<p>[建议] 在文件结尾处，保留一个空行。</p>
<h2 id="-">结构</h2>
<h3 id="-">缩进</h3>
<p>[强制] 使用 <code>4</code> 个空格做为一个缩进层级，不允许使用 <code>2</code> 个空格 或 <code>tab</code> 字符。</p>
<p>[强制] <code>switch</code> 下的 <code>case</code> 和 <code>default</code> 必须增加一个缩进层级。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
switch (variable) {

    case &#39;1&#39;:
        // do...
        break;

    case &#39;2&#39;:
        // do...
        break;

    default:
        // do...

}

// bad
switch (variable) {

case &#39;1&#39;:
    // do...
    break;

case &#39;2&#39;:
    // do...
    break;

default:
    // do...

}
</code></pre>
<h3 id="-">空格</h3>
<p>[强制] 二元运算符两侧必须有一个空格，一元运算符与操作对象之间不允许有空格。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var a = !arr.length;
a++;
a = b + c;
</code></pre>
<p>[强制] 用作代码块起始的左花括号 <code>{</code> 前必须有一个空格。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
if (condition) {
}

while (condition) {
}

function funcName() {
}

// bad
if (condition){
}

while (condition){
}

function funcName(){
}
</code></pre>
<p>[强制] <code>if / else / for / while / function / switch / do / try / catch / finally</code> 关键字后，必须有一个空格。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
if (condition) {
}

while (condition) {
}

(function () {
})();

// bad
if(condition) {
}

while(condition) {
}

(function() {
})();
</code></pre>
<p>[强制] 在对象创建时，属性中的 <code>:</code> 之后必须有空格，<code>:</code> 之前不允许有空格。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var obj = {
    a: 1,
    b: 2,
    c: 3
};

// bad
var obj = {
    a : 1,
    b:2,
    c :3
};
</code></pre>
<p>[强制] 函数声明、具名函数表达式、函数调用中，函数名和 <code>(</code> 之间不允许有空格。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
function funcName() {
}

var funcName = function funcName() {
};

funcName();

// bad
function funcName () {
}

var funcName = function funcName () {
};

funcName ();
</code></pre>
<p>[强制] <code>,</code> 和 <code>;</code> 前不允许有空格。如果不位于行尾，<code>,</code> 和 <code>;</code> 后必须跟一个空格。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
callFunc(a, b);

// bad
callFunc(a , b) ;
</code></pre>
<p>[强制] 在函数调用、函数声明、括号表达式、属性访问、<code>if / for / while / switch / catch</code> 等语句中，<code>()</code> 和 <code>[]</code> 内紧贴括号部分不允许有空格。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good

callFunc(param1, param2, param3);

save(this.list[this.indexes[i]]);

needIncream &amp;&amp; (variable += increament);

if (num &gt; list.length) {
}

while (len--) {
}


// bad

callFunc( param1, param2, param3 );

save( this.list[ this.indexes[ i ] ] );

needIncreament &amp;&amp; ( variable += increament );

if ( num &gt; list.length ) {
}

while ( len-- ) {
}
</code></pre>
<p>[强制] 单行声明的数组与对象，如果包含元素，<code>{}</code> 和 <code>[]</code> 内紧贴括号部分不允许包含空格。</p>
<p>解释：</p>
<p>声明包含元素的数组与对象，只有当内部元素的形式较为简单时，才允许写在一行。元素复杂的情况，还是应该换行书写。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var arr1 = [];
var arr2 = [1, 2, 3];
var obj1 = {};
var obj2 = {name: &#39;obj&#39;};
var obj3 = {
    name: &#39;obj&#39;,
    age: 20,
    sex: 1
};

// bad
var arr1 = [ ];
var arr2 = [ 1, 2, 3 ];
var obj1 = { };
var obj2 = { name: &#39;obj&#39; };
var obj3 = {name: &#39;obj&#39;, age: 20, sex: 1};
</code></pre>
<p>[强制] 行尾不得有多余的空格。</p>
<h3 id="-">换行</h3>
<p>[强制] 每个独立语句结束后必须换行。</p>
<p>[强制] 每行不得超过 <code>120</code> 个字符。</p>
<p>解释：</p>
<p>超长的不可分割的代码允许例外，比如复杂的正则表达式。长字符串不在例外之列。</p>
<p>[强制] 运算符处换行时，运算符必须在新行的行首。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
if (user.isAuthenticated()
    &amp;&amp; user.isInRole(&#39;admin&#39;)
    &amp;&amp; user.hasAuthority(&#39;add-admin&#39;)
    || user.hasAuthority(&#39;delete-admin&#39;)
) {
    // Code
}

var result = number1 + number2 + number3
    + number4 + number5;


// bad
if (user.isAuthenticated() &amp;&amp;
    user.isInRole(&#39;admin&#39;) &amp;&amp;
    user.hasAuthority(&#39;add-admin&#39;) ||
    user.hasAuthority(&#39;delete-admin&#39;)) {
    // Code
}

var result = number1 + number2 + number3 +
    number4 + number5;
</code></pre>
<p>[强制] 在函数声明、函数表达式、函数调用、对象创建、数组创建、<code>for</code> 语句等场景中，不允许在 <code>,</code> 或 <code>;</code> 前换行。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var obj = {
    a: 1,
    b: 2,
    c: 3
};

foo(
    aVeryVeryLongArgument,
    anotherVeryLongArgument,
    callback
);


// bad
var obj = {
    a: 1
    , b: 2
    , c: 3
};

foo(
    aVeryVeryLongArgument
    , anotherVeryLongArgument
    , callback
);
</code></pre>
<p>[建议] 不同行为或逻辑的语句集，使用空行隔开，更易阅读。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// 仅为按逻辑换行的示例，不代表setStyle的最优实现
function setStyle(element, property, value) {
    if (element == null) {
        return;
    }

    element.style[property] = value;
}
</code></pre>
<p>[建议] 在语句的行长度超过 <code>120</code> 时，根据逻辑条件合理缩进。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// 较复杂的逻辑条件组合，将每个条件独立一行，逻辑运算符放置在行首进行分隔，或将部分逻辑按逻辑组合进行分隔。
// 建议最终将右括号 ) 与左大括号 { 放在独立一行，保证与 `if` 内语句块能容易视觉辨识。
if (user.isAuthenticated()
    &amp;&amp; user.isInRole(&#39;admin&#39;)
    &amp;&amp; user.hasAuthority(&#39;add-admin&#39;)
    || user.hasAuthority(&#39;delete-admin&#39;)
) {
    // Code
}

// 按一定长度截断字符串，并使用 + 运算符进行连接。
// 分隔字符串尽量按语义进行，如不要在一个完整的名词中间断开。
// 特别的，对于 HTML 片段的拼接，通过缩进，保持和 HTML 相同的结构。
var html = &#39;&#39; // 此处用一个空字符串，以便整个 HTML 片段都在新行严格对齐
    + &#39;&lt;article&gt;&#39;
    +     &#39;&lt;h1&gt;Title here&lt;/h1&gt;&#39;
    +     &#39;&lt;p&gt;This is a paragraph&lt;/p&gt;&#39;
    +     &#39;&lt;footer&gt;Complete&lt;/footer&gt;&#39;
    + &#39;&lt;/article&gt;&#39;;

// 也可使用数组来进行拼接，相对 `+` 更容易调整缩进。
var html = [
    &#39;&lt;article&gt;&#39;,
        &#39;&lt;h1&gt;Title here&lt;/h1&gt;&#39;,
        &#39;&lt;p&gt;This is a paragraph&lt;/p&gt;&#39;,
        &#39;&lt;footer&gt;Complete&lt;/footer&gt;&#39;,
    &#39;&lt;/article&gt;&#39;
];
html = html.join(&#39;&#39;);

// 当参数过多时，将每个参数独立写在一行上，并将结束的右括号 ) 独立一行。
// 所有参数必须增加一个缩进。
foo(
    aVeryVeryLongArgument,
    anotherVeryLongArgument,
    callback
);

// 也可以按逻辑对参数进行组合。
// 最经典的是 baidu.format 函数，调用时将参数分为“模板”和“数据”两块
baidu.format(
    dateFormatTemplate,
    year, month, date, hour, minute, second
);

// 当函数调用时，如果有一个或以上参数跨越多行，应当每一个参数独立一行。
// 这通常出现在匿名函数或者对象初始化等作为参数时，如 `setTimeout` 函数等。
setTimeout(
    function () {
        alert(&#39;hello&#39;);
    },
    200
);

order.data.read(
    &#39;id=&#39; + me.model.id,
    function (data) {
        me.attchToModel(data.result);
        callback();
    },
    300
);

// 链式调用较长时采用缩进进行调整。
$(&#39;#items&#39;)
    .find(&#39;.selected&#39;)
    .highlight()
    .end();

// 三元运算符由3部分组成，因此其换行应当根据每个部分的长度不同，形成不同的情况。
var result = thisIsAVeryVeryLongCondition
    ? resultA : resultB;

var result = condition
    ? thisIsAVeryVeryLongResult
    : resultB;

// 数组和对象初始化的混用，严格按照每个对象的 `{` 和结束 `}` 在独立一行的风格书写。
var array = [
    {
        // ...
    },
    {
        // ...
    }
];
</code></pre>
<p>[建议] 对于 <code>if...else...</code>、<code>try...catch...finally</code> 等语句，推荐使用在 <code>}</code> 号后添加一个换行 的风格，使代码层次结构更清晰，阅读性更好。</p>
<p>示例：</p>
<pre><code class="lang-javascript">if (condition) {
    // some statements;
}
else {
    // some statements;
}

try {
    // some statements;
}
catch (ex) {
    // some statements;
}
</code></pre>
<h3 id="-">语句</h3>
<p>[强制] 不得省略语句结束的分号。</p>
<p>[强制] 在 <code>if / else / for / do / while</code> 语句中，即使只有一行，也不得省略块 <code>{...}</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
if (condition) {
    callFunc();
}

// bad
if (condition) callFunc();
if (condition)
    callFunc();
</code></pre>
<p>[强制] 函数定义结束不允许添加分号。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
function funcName() {
}

// bad
function funcName() {
};

// 如果是函数表达式，分号是不允许省略的。
var funcName = function () {
};
</code></pre>
<p>[强制] <code>IIFE</code> 必须在函数表达式外添加 <code>(</code>，非 <code>IIFE</code> 不得在函数表达式外添加 <code>(</code>。</p>
<p>解释：</p>
<p>IIFE = Immediately-Invoked Function Expression.</p>
<p>额外的 ( 能够让代码在阅读的一开始就能判断函数是否立即被调用，进而明白接下来代码的用途。而不是一直拖到底部才恍然大悟。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var task = (function () {
   // Code
   return result;
})();

var func = function () {
};


// bad
var task = function () {
    // Code
    return result;
}();

var func = (function () {
});
</code></pre>
<h2 id="-">命名</h2>
<p>[强制] <code>变量</code> 使用 <code>Camel命名法</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var loadingModules = {};
</code></pre>
<p>[强制] <code>常量</code> 使用 <code>全部字母大写，单词间下划线分隔</code> 的命名方式。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var HTML_ENTITY = {};
</code></pre>
<p>[强制] <code>函数</code> 使用 <code>Camel命名法</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function stringFormat(source) {
}
</code></pre>
<p>[强制] 函数的 <code>参数</code> 使用 <code>Camel命名法</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function hear(theBells) {
}
</code></pre>
<p>[强制] <code>类</code> 使用 <code>Pascal命名法</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function TextNode(options) {
}
</code></pre>
<p>[强制] 类的 <code>方法</code> / <code>属性</code> 使用 <code>Camel命名法</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function TextNode(value, engine) {
    this.value = value;
    this.engine = engine;
}

TextNode.prototype.clone = function () {
    return this;
};
</code></pre>
<p>[强制] <code>枚举变量</code> 使用 <code>Pascal命名法</code>，<code>枚举的属性</code> 使用 <code>全部字母大写，单词间下划线分隔</code> 的命名方式。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var TargetState = {
    READING: 1,
    READED: 2,
    APPLIED: 3,
    READY: 4
};
</code></pre>
<p>[强制] <code>命名空间</code> 使用 <code>Camel命名法</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">equipments.heavyWeapons = {};
</code></pre>
<p>[强制] 由多个单词组成的缩写词，在命名中，根据当前命名法和出现的位置，所有字母的大小写与首字母的大小写保持一致。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function XMLParser() {
}

function insertHTML(element, html) {
}

var httpRequest = new HTTPRequest();
</code></pre>
<p>[强制] <code>类名</code> 使用 <code>名词</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function Engine(options) {
}
</code></pre>
<p>[建议] <code>函数名</code> 使用 <code>动宾短语</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function getStyle(element) {
}
</code></pre>
<p>[建议] <code>boolean</code> 类型的变量使用 <code>is</code> 或 <code>has</code> 开头。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var isReady = false;
var hasMoreCommands = false;
</code></pre>
<p>[建议] <code>Promise对象</code> 用 <code>动宾短语的进行时</code> 表达。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var loadingData = ajax.get(&#39;url&#39;);
loadingData.then(callback);
</code></pre>
<h2 id="-">注释</h2>
<h3 id="-">单行注释</h3>
<p>[强制] 必须独占一行。<code>//</code> 后跟一个空格，缩进与下一行被注释说明的代码一致。</p>
<h3 id="-">多行注释</h3>
<p>[建议] 避免使用 <code>/*...*/</code> 这样的多行注释。有多行注释内容时，使用多个单行注释。</p>
<h3 id="-">文档化注释</h3>
<p>[强制] 为了便于代码阅读和自文档化，以下内容必须包含以 <code>/**...*/</code> 形式的块注释中。</p>
<p>解释：</p>
<ol>
<li>文件</li>
<li>namespace</li>
<li>类</li>
<li>函数或方法</li>
<li>类属性</li>
<li>事件</li>
<li>全局变量</li>
<li>常量</li>
<li>AMD 模块</li>
</ol>
<p>[强制] 文档注释前必须空一行。</p>
<p>[建议] 自文档化的文档说明 what，而不是 how。</p>
<h3 id="-">类型定义</h3>
<p>[强制] 类型定义都是以 <code>{</code> 开始, 以 <code>}</code> 结束。</p>
<p>解释：</p>
<p>常用类型如：{string}, {number}, {boolean}, {Object}, {Function}, {RegExp}, {Array}, {Date}。</p>
<p>类型不仅局限于内置的类型，也可以是自定义的类型。比如定义了一个类 Developer，就可以使用它来定义一个参数和返回值的类型。</p>
<p>[强制] 对于基本类型 {string}, {number}, {boolean}，首字母必须小写。</p>
<table>
<thead>
<tr>
<th>类型定义</th>
<th>语法示例</th>
<th>解释</th>
</tr>
</thead>
<tbody>
<tr>
<td>String</td>
<td>{string}</td>
<td>--</td>
</tr>
<tr>
<td>Number</td>
<td>{number}</td>
<td>--</td>
</tr>
<tr>
<td>Boolean</td>
<td>{boolean}</td>
<td>--</td>
</tr>
<tr>
<td>Object</td>
<td>{Object}</td>
<td>--</td>
</tr>
<tr>
<td>Function</td>
<td>{Function}</td>
<td>--</td>
</tr>
<tr>
<td>RegExp</td>
<td>{RegExp}</td>
<td>--</td>
</tr>
<tr>
<td>Array</td>
<td>{Array}</td>
<td>--</td>
</tr>
<tr>
<td>Date</td>
<td>{Date}</td>
<td>--</td>
</tr>
<tr>
<td>单一类型集合</td>
<td>{Array.&lt;string&gt;}</td>
<td>string 类型的数组</td>
</tr>
<tr>
<td>多类型</td>
<td>{(number｜boolean)}</td>
<td>可能是 number 类型, 也可能是 boolean 类型</td>
</tr>
<tr>
<td>允许为null</td>
<td>{?number}</td>
<td>可能是 number, 也可能是 null</td>
</tr>
<tr>
<td>不允许为null</td>
<td>{!Object}</td>
<td>Object 类型, 但不是 null</td>
</tr>
<tr>
<td>Function类型</td>
<td>{function(number, boolean)}</td>
<td>函数, 形参类型</td>
</tr>
<tr>
<td>Function带返回值</td>
<td>{function(number, boolean):string}</td>
<td>函数, 形参, 返回值类型</td>
</tr>
<tr>
<td>Promise</td>
<td>Promise.&lt;resolveType, rejectType&gt;</td>
<td>Promise，成功返回的数据类型，失败返回的错误类型</td>
</tr>
<tr>
<td>参数可选</td>
<td>@param {string=} name</td>
<td>可选参数, =为类型后缀</td>
</tr>
<tr>
<td>可变参数</td>
<td>@param {...number} args</td>
<td>变长参数,  ...为类型前缀</td>
</tr>
<tr>
<td>任意类型</td>
<td>{*}</td>
<td>任意类型</td>
</tr>
<tr>
<td>可选任意类型</td>
<td>@param {*=} name</td>
<td>可选参数，类型不限</td>
</tr>
<tr>
<td>可变任意类型</td>
<td>@param {...*} args</td>
<td>变长参数，类型不限</td>
</tr>
</tbody>
</table>
<h3 id="-">文件注释</h3>
<p>[强制] 文件顶部必须包含文件注释，用 <code>@file</code> 标识文件说明。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * @file Describe the file
 */
</code></pre>
<p>[建议] 文件注释中可以用 <code>@author</code> 标识开发者信息。</p>
<p>解释：</p>
<p>开发者信息能够体现开发人员对文件的贡献，并且能够让遇到问题或希望了解相关信息的人找到维护人。通常情况文件在被创建时标识的是创建者。随着项目的进展，越来越多的人加入，参与这个文件的开发，新的作者应该被加入 <code>@author</code> 标识。</p>
<p><code>@author</code> 标识具有多人时，原则是按照 <code>责任</code> 进行排序。通常的说就是如果有问题，就是找第一个人应该比找第二个人有效。比如文件的创建者由于各种原因，模块移交给了其他人或其他团队，后来因为新增需求，其他人在新增代码时，添加 <code>@author</code> 标识应该把自己的名字添加在创建人的前面。</p>
<p><code>@author</code> 中的名字不允许被删除。任何劳动成果都应该被尊重。</p>
<p>业务项目中，一个文件可能被多人频繁修改，并且每个人的维护时间都可能不会很长，不建议为文件增加 <code>@author</code> 标识。通过版本控制系统追踪变更，按业务逻辑单元确定模块的维护责任人，通过文档与wiki跟踪和查询，是更好的责任管理方式。</p>
<p>对于业务逻辑无关的技术型基础项目，特别是开源的公共项目，应使用 <code>@author</code> 标识。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * @file Describe the file
 * @author author-name(mail-name@domain.com)
 *         author-name2(mail-name2@domain.com)
 */
</code></pre>
<h3 id="-">命名空间注释</h3>
<p>[建议] 命名空间使用 <code>@namespace</code> 标识。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * @namespace
 */
var util = {};
</code></pre>
<h3 id="-">类注释</h3>
<p>[建议] 使用 <code>@class</code> 标记类或构造函数。</p>
<p>解释：</p>
<p>对于使用对象 <code>constructor</code> 属性来定义的构造函数，可以使用 <code>@constructor</code> 来标记。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 描述
 *
 * @class
 */
function Developer() {
    // constructor body
}
</code></pre>
<p>[建议] 使用 <code>@extends</code> 标记类的继承信息。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 描述
 *
 * @class
 * @extends Developer
 */
function Fronteer() {
    Developer.call(this);
    // constructor body
}
util.inherits(Fronteer, Developer);
</code></pre>
<p>[强制] 使用包装方式扩展类成员时， 必须通过 <code>@lends</code> 进行重新指向。</p>
<p>解释：</p>
<p>没有 <code>@lends</code> 标记将无法为该类生成包含扩展类成员的文档。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 类描述
 *
 * @class
 * @extends Developer
 */
function Fronteer() {
    Developer.call(this);
    // constructor body
}

util.extend(
    Fronteer.prototype,
    /** @lends Fronteer.prototype */{
        getLevel: function () {
            // TODO
        }
    }
);
</code></pre>
<p>[强制] 类的属性或方法等成员信息使用 <code>@public</code> / <code>@protected</code> / <code>@private</code> 中的任意一个，指明可访问性。</p>
<p>解释：</p>
<p>生成的文档中将有可访问性的标记，避免用户直接使用非 <code>public</code> 的属性或方法。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 类描述
 *
 * @class
 * @extends Developer
 */
var Fronteer = function () {
    Developer.call(this);

    /**
     * 属性描述
     *
     * @type {string}
     * @private
     */
    this.level = &#39;T12&#39;;

    // constructor body
};
util.inherits(Fronteer, Developer);

/**
 * 方法描述
 *
 * @private
 * @return {string} 返回值描述
 */
Fronteer.prototype.getLevel = function () {
};
</code></pre>
<h3 id="-">函数/方法注释</h3>
<p>[强制] 函数/方法注释必须包含函数说明，有参数和返回值时必须使用注释标识。</p>
<p>解释：</p>
<p>当 <code>return</code> 关键字仅作退出函数/方法使用时，无须对返回值作注释标识。</p>
<p>[强制] 参数和返回值注释必须包含类型信息，且不允许省略参数的说明。</p>
<p>[建议] 当函数是内部函数，外部不可访问时，可以使用 <code>@inner</code> 标识。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 函数描述
 *
 * @param {string} p1 参数1的说明
 * @param {string} p2 参数2的说明，比较长
 *     那就换行了.
 * @param {number=} p3 参数3的说明（可选）
 * @return {Object} 返回值描述
 */
function foo(p1, p2, p3) {
    var p3 = p3 || 10;
    return {
        p1: p1,
        p2: p2,
        p3: p3
    };
}
</code></pre>
<p>[强制] 对 Object 中各项的描述， 必须使用 <code>@param</code> 标识。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 函数描述
 *
 * @param {Object} option 参数描述
 * @param {string} option.url option项描述
 * @param {string=} option.method option项描述，可选参数
 */
function foo(option) {
    // TODO
}
</code></pre>
<p>[建议] 重写父类方法时， 应当添加 <code>@override</code> 标识。如果重写的形参个数、类型、顺序和返回值类型均未发生变化，可省略 <code>@param</code>、<code>@return</code>，仅用 <code>@override</code> 标识，否则仍应作完整注释。</p>
<p>解释：</p>
<p>简而言之，当子类重写的方法能直接套用父类的方法注释时可省略对参数与返回值的注释。</p>
<h3 id="-">事件注释</h3>
<p>[强制] 必须使用 <code>@event</code> 标识事件，事件参数的标识与方法描述的参数标识相同。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 值变更时触发
 *
 * @event Select#change
 * @param {Object} e e描述
 * @param {string} e.before before描述
 * @param {string} e.after after描述
 */
this.fire(
    &#39;change&#39;,
    {
        before: &#39;foo&#39;,
        after: &#39;bar&#39;
    }
);
</code></pre>
<p>[强制] 在会广播事件的函数前使用 <code>@fires</code> 标识广播的事件，在广播事件代码前使用 <code>@event</code> 标识事件。</p>
<p>[建议] 对于事件对象的注释，使用 <code>@param</code> 标识，生成文档时可读性更好。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 点击处理
 *
 * @fires Select#change
 * @private
 */
Select.prototype.clickHandler = function () {

    /**
     * 值变更时触发
     *
     * @event Select#change
     * @param {Object} e e描述
     * @param {string} e.before before描述
     * @param {string} e.after after描述
     */
    this.fire(
        &#39;change&#39;,
        {
            before: &#39;foo&#39;,
            after: &#39;bar&#39;
        }
    );
};
</code></pre>
<h3 id="-">常量注释</h3>
<p>[强制] 常量必须使用 <code>@const</code> 标记，并包含说明和类型信息。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 常量说明
 *
 * @const
 * @type {string}
 */
var REQUEST_URL = &#39;myurl.do&#39;;
</code></pre>
<h3 id="-">复杂类型注释</h3>
<p>[建议] 对于类型未定义的复杂结构的注释，可以使用 <code>@typedef</code> 标识来定义。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// `namespaceA~` 可以换成其它 namepaths 前缀，目的是为了生成文档中能显示 `@typedef` 定义的类型和链接。
/**
 * 服务器
 *
 * @typedef {Object} namespaceA~Server
 * @property {string} host 主机
 * @property {number} port 端口
 */

/**
 * 服务器列表
 *
 * @type {Array.&lt;namespaceA~Server&gt;}
 */
var servers = [
    {
        host: &#39;1.2.3.4&#39;,
        port: 8080
    },
    {
        host: &#39;1.2.3.5&#39;,
        port: 8081
    }
];
</code></pre>
<h3 id="amd-">AMD 模块注释</h3>
<p>[强制] AMD 模块使用 <code>@module</code> 或 <code>@exports</code> 标识。</p>
<p>解释：</p>
<p>@exports 与 @module 都可以用来标识模块，区别在于 @module 可以省略模块名称。而只使用 @exports 时在 namepaths 中可以省略 module: 前缀。</p>
<p>示例：</p>
<pre><code class="lang-javascript">define(
    function (require) {

        /**
         * foo description
         *
         * @exports Foo
         */
        var foo = {
            // TODO
        };

        /**
         * baz description
         *
         * @return {boolean} return description
         */
        foo.baz = function () {
            // TODO
        };

        return foo;

    }
);
</code></pre>
<p>也可以在 exports 变量前使用 @module 标识：</p>
<pre><code class="lang-javascript">define(
    function (require) {

        /**
         * module description.
         *
         * @module foo
         */
        var exports = {};


        /**
         * bar description
         *
         */
        exports.bar = function () {
            // TODO
        };

        return exports;
    }
);
</code></pre>
<p>如果直接使用 factory 的 exports 参数，还可以：</p>
<pre><code class="lang-javascript">/**
 * module description.
 *
 * @module
 */
define(
    function (require, exports) {

        /**
         * bar description
         *
         */
        exports.bar = function () {
            // TODO
        };
        return exports;
    }
);
</code></pre>
<p>[强制] 对于已使用 <code>@module</code> 标识为 AMD模块 的引用，在 <code>namepaths</code> 中必须增加 <code>module:</code> 作前缀。</p>
<p>解释：</p>
<p>namepaths 没有 module: 前缀时，生成的文档中将无法正确生成链接。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 点击处理
 *
 * @fires module:Select#change
 * @private
 */
Select.prototype.clickHandler = function () {
    /**
     * 值变更时触发
     *
     * @event module:Select#change
     * @param {Object} e e描述
     * @param {string} e.before before描述
     * @param {string} e.after after描述
     */
    this.fire(
        &#39;change&#39;,
        {
            before: &#39;foo&#39;,
            after: &#39;bar&#39;
        }
    );
};
</code></pre>
<p>[建议] 对于类定义的模块，可以使用 <code>@alias</code> 标识构建函数。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * A module representing a jacket.
 * @module jacket
 */
define(
    function () {

        /**
         * @class
         * @alias module:jacket
         */
        var Jacket = function () {
        };

        return Jacket;
    }
);
</code></pre>
<p>[建议] 多模块定义时，可以使用 <code>@exports</code> 标识各个模块。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// one module
define(&#39;html/utils&#39;,
    /**
     * Utility functions to ease working with DOM elements.
     * @exports html/utils
     */
    function () {
        var exports = {
        };

        return exports;
    }
);

// another module
define(&#39;tag&#39;,
    /** @exports tag */
    function () {
        var exports = {
        };

        return exports;
    }
);
</code></pre>
<p>[建议] 对于 exports 为 Object 的模块，可以使用<code>@namespace</code>标识。</p>
<p>解释：</p>
<p>使用 @namespace 而不是 @module 或 @exports 时，对模块的引用可以省略 module: 前缀。</p>
<p>[建议] 对于 exports 为类名的模块，使用 <code>@class</code> 和 <code>@exports</code> 标识。</p>
<p>示例：</p>
<pre><code class="lang-javascript">
// 只使用 @class Bar 时，类方法和属性都必须增加 @name Bar#methodName 来标识，与 @exports 配合可以免除这一麻烦，并且在引用时可以省去 module: 前缀。
// 另外需要注意类名需要使用 var 定义的方式。

/**
 * Bar description
 *
 * @see foo
 * @exports  Bar
 * @class
 */
var Bar = function () {
    // TODO
};

/**
 * baz description
 *
 * @return {(string|Array)} return description
 */
Bar.prototype.baz = function () {
    // TODO
};
</code></pre>
<h3 id="-">细节注释</h3>
<p>对于内部实现、不容易理解的逻辑说明、摘要信息等，我们可能需要编写细节注释。</p>
<p> [建议] 细节注释遵循单行注释的格式。说明必须换行时，每行是一个单行注释的起始。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function foo(p1, p2, opt_p3) {
    // 这里对具体内部逻辑进行说明
    // 说明太长需要换行
    for (...) {
        ....
    }
}
</code></pre>
<p>[强制] 有时我们会使用一些特殊标记进行说明。特殊标记必须使用单行注释的形式。下面列举了一些常用标记：</p>
<p>解释：</p>
<ol>
<li>TODO: 有功能待实现。此时需要对将要实现的功能进行简单说明。</li>
<li>FIXME: 该处代码运行没问题，但可能由于时间赶或者其他原因，需要修正。此时需要对如何修正进行简单说明。</li>
<li>HACK: 为修正某些问题而写的不太好或者使用了某些诡异手段的代码。此时需要对思路或诡异手段进行描述。</li>
<li>XXX: 该处存在陷阱。此时需要对陷阱进行描述。</li>
</ol>
<h1 id="-">语言特性</h1>
<h2 id="-">变量</h2>
<p>[强制] 变量、函数在使用前必须先定义。</p>
<p>解释：</p>
<p>不通过 var 定义变量将导致变量污染全局环境。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var name = &#39;MyName&#39;;

// bad
name = &#39;MyName&#39;;
</code></pre>
<p>原则上不建议使用全局变量，对于已有的全局变量或第三方框架引入的全局变量，需要根据检查工具的语法标识。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/* globals jQuery */
var element = jQuery(&#39;#element-id&#39;);
</code></pre>
<p>[强制] 每个 <code>var</code> 只能声明一个变量。</p>
<p>解释：</p>
<p>一个 <code>var</code> 声明多个变量，容易导致较长的行长度，并且在修改时容易造成逗号和分号的混淆。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var hangModules = [];
var missModules = [];
var visited = {};

// bad
var hangModules = [],
    missModules = [],
    visited = {};
</code></pre>
<p>[强制] 变量必须 <code>即用即声明</code>，不得在函数或其它形式的代码块起始位置统一声明所有变量。</p>
<p>解释：</p>
<p>变量声明与使用的距离越远，出现的跨度越大，代码的阅读与维护成本越高。虽然JavaScript的变量是函数作用域，还是应该根据编程中的意图，缩小变量出现的距离空间。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
function kv2List(source) {
    var list = [];

    for (var key in source) {
        if (source.hasOwnProperty(key)) {
            var item = {
                k: key,
                v: source[key]
            };

            list.push(item);
        }
    }

    return list;
}

// bad
function kv2List(source) {
    var list = [];
    var key;
    var item;

    for (key in source) {
        if (source.hasOwnProperty(key)) {
            item = {
                k: key,
                v: source[key]
            };

            list.push(item);
        }
    }

    return list;
}
</code></pre>
<h2 id="-">条件</h2>
<p>[强制] 在 Equality Expression 中使用类型严格的 <code>===</code>。仅当判断 <code>null</code> 或 <code>undefined</code> 时，允许使用 <code>== null</code>。</p>
<p>解释：</p>
<p>使用 <code>===</code> 可以避免等于判断中隐式的类型转换。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
if (age === 30) {
    // ......
}

// bad
if (age == 30) {
    // ......
}
</code></pre>
<p>[建议] 尽可能使用简洁的表达式。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// 字符串为空

// good
if (!name) {
    // ......
}

// bad
if (name === &#39;&#39;) {
    // ......
}
</code></pre>
<pre><code class="lang-javascript">// 字符串非空

// good
if (name) {
    // ......
}

// bad
if (name !== &#39;&#39;) {
    // ......
}
</code></pre>
<pre><code class="lang-javascript">// 数组非空

// good
if (collection.length) {
    // ......
}

// bad
if (collection.length &gt; 0) {
    // ......
}
</code></pre>
<pre><code class="lang-javascript">// 布尔不成立

// good
if (!notTrue) {
    // ......
}

// bad
if (notTrue === false) {
    // ......
}
</code></pre>
<pre><code class="lang-javascript">// null 或 undefined

// good
if (noValue == null) {
  // ......
}

// bad
if (noValue === null || typeof noValue === &#39;undefined&#39;) {
  // ......
}
</code></pre>
<p>[建议] 按执行频率排列分支的顺序。</p>
<p>解释：</p>
<p>按执行频率排列分支的顺序好处是：</p>
<ol>
<li>阅读的人容易找到最常见的情况，增加可读性。</li>
<li>提高执行效率。</li>
</ol>
<p>[建议] 对于相同变量或表达式的多值条件，用 <code>switch</code> 代替 <code>if</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
switch (typeof variable) {
    case &#39;object&#39;:
        // ......
        break;
    case &#39;number&#39;:
    case &#39;boolean&#39;:
    case &#39;string&#39;:
        // ......
        break;
}

// bad
var type = typeof variable;
if (type === &#39;object&#39;) {
    // ......
}
else if (type === &#39;number&#39; || type === &#39;boolean&#39; || type === &#39;string&#39;) {
    // ......
}
</code></pre>
<p>[建议] 如果函数或全局中的 <code>else</code> 块后没有任何语句，可以删除 <code>else</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
function getName() {
    if (name) {
        return name;
    }

    return &#39;unnamed&#39;;
}

// bad
function getName() {
    if (name) {
        return name;
    }
    else {
        return &#39;unnamed&#39;;
    }
}
</code></pre>
<h2 id="-">循环</h2>
<p>[建议] 不要在循环体中包含函数表达式，事先将函数提取到循环体外。</p>
<p>解释：</p>
<p>循环体中的函数表达式，运行过程中会生成循环次数个函数对象。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
function clicker() {
    // ......
}

for (var i = 0, len = elements.length; i &lt; len; i++) {
    var element = elements[i];
    addListener(element, &#39;click&#39;, clicker);
}


// bad
for (var i = 0, len = elements.length; i &lt; len; i++) {
    var element = elements[i];
    addListener(element, &#39;click&#39;, function () {});
}
</code></pre>
<p>[建议] 对循环内多次使用的不变值，在循环外用变量缓存。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var width = wrap.offsetWidth + &#39;px&#39;;
for (var i = 0, len = elements.length; i &lt; len; i++) {
    var element = elements[i];
    element.style.width = width;
    // ......
}


// bad
for (var i = 0, len = elements.length; i &lt; len; i++) {
    var element = elements[i];
    element.style.width = wrap.offsetWidth + &#39;px&#39;;
    // ......
}
</code></pre>
<p>[建议] 对有序集合进行遍历时，缓存 <code>length</code>。</p>
<p>解释：</p>
<p>虽然现代浏览器都对数组长度进行了缓存，但对于一些宿主对象和老旧浏览器的数组对象，在每次 <code>length</code> 访问时会动态计算元素个数，此时缓存 <code>length</code> 能有效提高程序性能。</p>
<p>示例：</p>
<pre><code class="lang-javascript">for (var i = 0, len = elements.length; i &lt; len; i++) {
    var element = elements[i];
    // ......
}
</code></pre>
<p>[建议] 对有序集合进行顺序无关的遍历时，使用逆序遍历。</p>
<p>解释：</p>
<p>逆序遍历可以节省变量，代码比较优化。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var len = elements.length;
while (len--) {
    var element = elements[len];
    // ......
}
</code></pre>
<h2 id="-">类型</h2>
<h3 id="-">类型检测</h3>
<p>[建议] 类型检测优先使用 <code>typeof</code>。对象类型检测使用 <code>instanceof</code>。<code>null</code> 或 <code>undefined</code> 的检测使用 <code>== null</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// string
typeof variable === &#39;string&#39;

// number
typeof variable === &#39;number&#39;

// boolean
typeof variable === &#39;boolean&#39;

// Function
typeof variable === &#39;function&#39;

// Object
typeof variable === &#39;object&#39;

// RegExp
variable instanceof RegExp

// Array
variable instanceof Array

// null
variable === null

// null or undefined
variable == null

// undefined
typeof variable === &#39;undefined&#39;
</code></pre>
<h3 id="-">类型转换</h3>
<p>[建议] 转换成 <code>string</code> 时，使用 <code>+ &#39;&#39;</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
num + &#39;&#39;;

// bad
new String(num);
num.toString();
String(num);
</code></pre>
<p>[建议] 转换成 <code>number</code> 时，通常使用 <code>+</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
+str;

// bad
Number(str);
</code></pre>
<p>[建议] <code>string</code> 转换成 <code>number</code>，要转换的字符串结尾包含非数字并期望忽略时，使用 <code>parseInt</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var width = &#39;200px&#39;;
parseInt(width, 10);
</code></pre>
<p>[强制] 使用 <code>parseInt</code> 时，必须指定进制。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
parseInt(str, 10);

// bad
parseInt(str);
</code></pre>
<p>[建议] 转换成 <code>boolean</code> 时，使用 <code>!!</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var num = 3.14;
!!num;
</code></pre>
<p>[建议] <code>number</code> 去除小数点，使用 <code>Math.floor</code> / <code>Math.round</code> / <code>Math.ceil</code>，不使用 <code>parseInt</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var num = 3.14;
Math.ceil(num);

// bad
var num = 3.14;
parseInt(num, 10);
</code></pre>
<h3 id="-">字符串</h3>
<p>[强制] 字符串开头和结束使用单引号 <code>&#39;</code>。</p>
<p>解释：</p>
<ol>
<li>输入单引号不需要按住 <code>shift</code>，方便输入。</li>
<li>实际使用中，字符串经常用来拼接 HTML。为方便 HTML 中包含双引号而不需要转义写法。</li>
</ol>
<p>示例：</p>
<pre><code class="lang-javascript">var str = &#39;我是一个字符串&#39;;
var html = &#39;&lt;div class=&quot;cls&quot;&gt;拼接HTML可以省去双引号转义&lt;/div&gt;&#39;;
</code></pre>
<p>[建议] 使用 <code>数组</code> 或 <code>+</code> 拼接字符串。</p>
<p>解释：</p>
<ol>
<li>使用 <code>+</code> 拼接字符串，如果拼接的全部是 StringLiteral，压缩工具可以对其进行自动合并的优化。所以，静态字符串建议使用 <code>+</code> 拼接。</li>
<li>在现代浏览器下，使用 <code>+</code> 拼接字符串，性能较数组的方式要高。</li>
<li>如需要兼顾老旧浏览器，应尽量使用数组拼接字符串。</li>
</ol>
<p>示例：</p>
<pre><code class="lang-javascript">// 使用数组拼接字符串
var str = [
    // 推荐换行开始并缩进开始第一个字符串, 对齐代码, 方便阅读.
    &#39;&lt;ul&gt;&#39;,
        &#39;&lt;li&gt;第一项&lt;/li&gt;&#39;,
        &#39;&lt;li&gt;第二项&lt;/li&gt;&#39;,
    &#39;&lt;/ul&gt;&#39;
].join(&#39;&#39;);

// 使用 `+` 拼接字符串
var str2 = &#39;&#39; // 建议第一个为空字符串, 第二个换行开始并缩进开始, 对齐代码, 方便阅读
    + &#39;&lt;ul&gt;&#39;,
    +    &#39;&lt;li&gt;第一项&lt;/li&gt;&#39;,
    +    &#39;&lt;li&gt;第二项&lt;/li&gt;&#39;,
    + &#39;&lt;/ul&gt;&#39;;
</code></pre>
<p>[建议] 使用字符串拼接的方式生成HTML，需要根据语境进行合理的转义。</p>
<p>解释：</p>
<p>在 <code>JavaScript</code> 中拼接，并且最终将输出到页面中的字符串，需要进行合理转义，以防止安全漏洞。下面的示例代码为场景说明，不能直接运行。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// HTML 转义
var str = &#39;&lt;p&gt;&#39; + htmlEncode(content) + &#39;&lt;/p&gt;&#39;;

// HTML 转义
var str = &#39;&lt;input type=&quot;text&quot; value=&quot;&#39; + htmlEncode(value) + &#39;&quot;&gt;&#39;;

// URL 转义
var str = &#39;&lt;a href=&quot;/?key=&#39; + htmlEncode(urlEncode(value)) + &#39;&quot;&gt;link&lt;/a&gt;&#39;;

// JavaScript字符串 转义 + HTML 转义
var str = &#39;&lt;button onclick=&quot;check(\&#39;&#39; + htmlEncode(strLiteral(name)) + &#39;\&#39;)&quot;&gt;提交&lt;/button&gt;&#39;;
</code></pre>
<p>[建议] 复杂的数据到视图字符串的转换过程，选用一种模板引擎。</p>
<p>解释：</p>
<p>使用模板引擎有如下好处：</p>
<ol>
<li>在开发过程中专注于数据，将视图生成的过程由另外一个层级维护，使程序逻辑结构更清晰。</li>
<li>优秀的模板引擎，通过模板编译技术和高质量的编译产物，能获得比手工拼接字符串更高的性能。</li>
<li><p>模板引擎能方便的对动态数据进行相应的转义，部分模板引擎默认进行HTML转义，安全性更好。</p>
</li>
<li><p>artTemplate: 体积较小，在所有环境下性能高，语法灵活。</p>
</li>
<li>dot.js: 体积小，在现代浏览器下性能高，语法灵活。</li>
<li>etpl: 体积较小，在所有环境下性能高，模板复用性高，语法灵活。</li>
<li>handlebars: 体积大，在所有环境下性能高，扩展性高。</li>
<li>hogon: 体积小，在现代浏览器下性能高。</li>
<li>nunjucks: 体积较大，性能一般，模板复用性高。</li>
</ol>
<h2 id="-">对象</h2>
<p>[强制] 使用对象字面量 <code>{}</code> 创建新 <code>Object</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var obj = {};

// bad
var obj = new Object();
</code></pre>
<p>[建议] 对象创建时，如果一个对象的所有 <code>属性</code> 均可以不添加引号，建议所有 <code>属性</code> 不添加引号。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var info = {
    name: &#39;someone&#39;,
    age: 28
};
</code></pre>
<p>[建议] 对象创建时，如果任何一个 <code>属性</code> 需要添加引号，则所有 <code>属性</code> 建议添加 <code>&#39;</code>。</p>
<p>解释：</p>
<p>如果属性不符合 Identifier 和 NumberLiteral 的形式，就需要以 StringLiteral 的形式提供。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var info = {
    &#39;name&#39;: &#39;someone&#39;,
    &#39;age&#39;: 28,
    &#39;more-info&#39;: &#39;...&#39;
};

// bad
var info = {
    name: &#39;someone&#39;,
    age: 28,
    &#39;more-info&#39;: &#39;...&#39;
};
</code></pre>
<p>[强制] 不允许修改和扩展任何原生对象和宿主对象的原型。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// 以下行为绝对禁止
String.prototype.trim = function () {
};
</code></pre>
<p>[建议] 属性访问时，尽量使用 <code>.</code>。</p>
<p>解释：</p>
<p>属性名符合 Identifier 的要求，就可以通过 <code>.</code> 来访问，否则就只能通过 <code>[expr]</code> 方式访问。</p>
<p>通常在 JavaScript 中声明的对象，属性命名是使用 Camel 命名法，用 <code>.</code> 来访问更清晰简洁。部分特殊的属性（比如来自后端的 JSON ），可能采用不寻常的命名方式，可以通过 <code>[expr]</code> 方式访问。</p>
<p>示例：</p>
<pre><code class="lang-javascript">info.age;
info[&#39;more-info&#39;];
</code></pre>
<p>[建议] <code>for in</code> 遍历对象时, 使用 <code>hasOwnProperty</code> 过滤掉原型中的属性。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var newInfo = {};
for (var key in info) {
    if (info.hasOwnProperty(key)) {
        newInfo[key] = info[key];
    }
}
</code></pre>
<h2 id="-">数组</h2>
<p>[强制] 使用数组字面量 <code>[]</code> 创建新数组，除非想要创建的是指定长度的数组。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
var arr = [];

// bad
var arr = new Array();
</code></pre>
<p>[强制] 遍历数组不使用 <code>for in</code>。</p>
<p>解释：</p>
<p>数组对象可能存在数字以外的属性, 这种情况下 <code>for in</code> 不会得到正确结果。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var arr = [&#39;a&#39;, &#39;b&#39;, &#39;c&#39;];

// 这里仅作演示, 实际中应使用 Object 类型
arr.other = &#39;other things&#39;;

// 正确的遍历方式
for (var i = 0, len = arr.length; i &lt; len; i++) {
    console.log(i);
}

// 错误的遍历方式
for (var i in arr) {
    console.log(i);
}
</code></pre>
<p>[建议] 不因为性能的原因自己实现数组排序功能，尽量使用数组的 <code>sort</code> 方法。</p>
<p>解释：</p>
<p>自己实现的常规排序算法，在性能上并不优于数组默认的 <code>sort</code> 方法。以下两种场景可以自己实现排序：</p>
<ol>
<li>需要稳定的排序算法，达到严格一致的排序结果。</li>
<li>数据特点鲜明，适合使用桶排。</li>
</ol>
<p>[建议] 清空数组使用 <code>.length = 0</code>。</p>
<h2 id="-">函数</h2>
<h3 id="-">函数长度</h3>
<p>[建议] 一个函数的长度控制在 <code>50</code> 行以内。</p>
<p>解释：</p>
<p>将过多的逻辑单元混在一个大函数中，易导致难以维护。一个清晰易懂的函数应该完成单一的逻辑单元。复杂的操作应进一步抽取，通过函数的调用来体现流程。</p>
<p>特定算法等不可分割的逻辑允许例外。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function syncViewStateOnUserAction() {
    if (x.checked) {
        y.checked = true;
        z.value = &#39;&#39;;
    }
    else {
        y.checked = false;
    }

    if (a.value) {
        warning.innerText = &#39;&#39;;
        submitButton.disabled = false;
    }
    else {
        warning.innerText = &#39;Please enter it&#39;;
        submitButton.disabled = true;
    }
}

// 直接阅读该函数会难以明确其主线逻辑，因此下方是一种更合理的表达方式：

function syncViewStateOnUserAction() {
    syncXStateToView();
    checkAAvailability();
}

function syncXStateToView() {
    y.checked = x.checked;

    if (x.checked) {
        z.value = &#39;&#39;;
    }
}

function checkAAvailability() {
    if (a.value) {
        clearWarnignForA();
    }
    else {
        displayWarningForAMissing();
    }
}
</code></pre>
<h3 id="-">参数设计</h3>
<p>[建议] 一个函数的参数控制在 <code>6</code> 个以内。</p>
<p>解释：</p>
<p>除去不定长参数以外，函数具备不同逻辑意义的参数建议控制在 <code>6</code> 个以内，过多参数会导致维护难度增大。</p>
<p>某些情况下，如使用 AMD Loader 的 <code>require</code> 加载多个模块时，其 <code>callback</code> 可能会存在较多参数，因此对函数参数的个数不做强制限制。</p>
<p>[建议] 通过 <code>options</code> 参数传递非数据输入型参数。</p>
<p>解释：</p>
<p>有些函数的参数并不是作为算法的输入，而是对算法的某些分支条件判断之用，此类参数建议通过一个 <code>options</code> 参数传递。</p>
<p>如下函数：</p>
<pre><code class="lang-javascript">/**
 * 移除某个元素
 *
 * @param {Node} element 需要移除的元素
 * @param {boolean} removeEventListeners 是否同时将所有注册在元素上的事件移除
 */
function removeElement(element, removeEventListeners) {
    element.parent.removeChild(element);

    if (removeEventListeners) {
        element.clearEventListeners();
    }
}
</code></pre>
<p>可以转换为下面的签名：</p>
<pre><code class="lang-javascript">/**
 * 移除某个元素
 *
 * @param {Node} element 需要移除的元素
 * @param {Object} options 相关的逻辑配置
 * @param {boolean} options.removeEventListeners 是否同时将所有注册在元素上的事件移除
 */
function removeElement(element, options) {
    element.parent.removeChild(element);

    if (options.removeEventListeners) {
        element.clearEventListeners();
    }
}
</code></pre>
<p>这种模式有几个显著的优势：</p>
<ul>
<li><code>boolean</code> 型的配置项具备名称，从调用的代码上更易理解其表达的逻辑意义。</li>
<li>当配置项有增长时，无需无休止地增加参数个数，不会出现 <code>removeElement(element, true, false, false, 3)</code> 这样难以理解的调用代码。</li>
<li>当部分配置参数可选时，多个参数的形式非常难处理重载逻辑，而使用一个 options 对象只需判断属性是否存在，实现得以简化。</li>
</ul>
<h3 id="-">闭包</h3>
<p>[建议] 在适当的时候将闭包内大对象置为 <code>null</code>。</p>
<p>解释：</p>
<p>在 JavaScript 中，无需特别的关键词就可以使用闭包，一个函数可以任意访问在其定义的作用域外的变量。需要注意的是，函数的作用域是静态的，即在定义时决定，与调用的时机和方式没有任何关系。</p>
<p>闭包会阻止一些变量的垃圾回收，对于较老旧的 JavaScript 引擎，可能导致外部所有变量均无法回收。</p>
<p>首先一个较为明确的结论是，以下内容会影响到闭包内变量的回收：</p>
<ul>
<li>嵌套的函数中是否有使用该变量。</li>
<li>嵌套的函数中是否有 <strong>直接调用eval</strong>。</li>
<li>是否使用了 with 表达式。</li>
</ul>
<p>Chakra、V8 和 SpiderMonkey 将受以上因素的影响，表现出不尽相同又较为相似的回收策略，而 JScript.dll 和 Carakan 则完全没有这方面的优化，会完整保留整个 LexicalEnvironment 中的所有变量绑定，造成一定的内存消耗。</p>
<p>由于对闭包内变量有回收优化策略的 Chakra、V8 和 SpiderMonkey 引擎的行为较为相似，因此可以总结如下，当返回一个函数 <strong>fn</strong> 时：</p>
<ol>
<li>如果 <strong>fn</strong> 的 <code>[[Scope]]</code> 是 ObjectEnvironment（with 表达式生成 ObjectEnvironment，函数和 catch 表达式生成 DeclarativeEnvironment），则：<ol>
<li>如果是 V8 引擎，则退出全过程。</li>
<li>如果是 SpiderMonkey，则处理该 ObjectEnvironment 的外层 LexicalEnvironment。</li>
</ol>
</li>
<li>获取当前 LexicalEnvironment 下的所有类型为 Function 的对象，对于每一个 Function 对象，分析其 FunctionBody：<ol>
<li>如果 FunctionBody 中含有 <strong>直接调用 eval</strong>，则退出全过程。</li>
<li>否则得到所有的 Identifier。</li>
<li>对于每一个 Identifier，设其为 <strong>name</strong>，根据查找变量引用的规则，从 LexicalEnvironment 中找出名称为 <strong>name</strong> 的绑定 binding。</li>
<li>对 binding 添加 <strong>notSwap</strong> 属性，其值为 <code>true</code>。</li>
</ol>
</li>
<li>检查当前 LexicalEnvironment 中的每一个变量绑定，如果该绑定有 <strong>notSwap</strong> 属性且值为 <code>true</code>，则：<ol>
<li>如果是 V8 引擎，删除该绑定。</li>
<li>如果是 SpiderMonkey，将该绑定的值设为 <code>undefined</code>，将删除 <strong>notSwap</strong> 属性。</li>
</ol>
</li>
</ol>
<p>对于 Chakra 引擎，暂无法得知是按 V8 的模式还是按 SpiderMonkey 的模式进行。</p>
<p>如果有 <strong>非常庞大</strong> 的对象，且预计会在 <strong>老旧的引擎</strong> 中执行，则使用闭包时，注意将闭包不需要的对象置为空引用。</p>
<p>[建议] 使用 <code>IIFE</code> 避免 <code>Lift 效应</code>。</p>
<p>解释：</p>
<p>在引用函数外部变量时，函数执行时外部变量的值由运行时决定而非定义时，最典型的场景如下：</p>
<pre><code class="lang-javascript">var tasks = [];
for (var i = 0; i &lt; 5; i++) {
    tasks[tasks.length] = function () {
        console.log(&#39;Current cursor is at &#39; + i);
    };
}

var len = tasks.length;
while (len--) {
    tasks[len]();
}
</code></pre>
<p>以上代码对 tasks 中的函数的执行均会输出 <code>Current cursor is at 5</code>，往往不符合预期。</p>
<p>此现象称为 <strong>Lift 效应</strong> 。解决的方式是通过额外加上一层闭包函数，将需要的外部变量作为参数传递来解除变量的绑定关系：</p>
<pre><code class="lang-javascript">var tasks = [];
for (var i = 0; i &lt; 5; i++) {
    // 注意有一层额外的闭包
    tasks[tasks.length] = (function (i) {
        return function () {
            console.log(&#39;Current cursor is at &#39; + i);
        };
    })(i);
}

var len = tasks.length;
while (len--) {
    tasks[len]();
}
</code></pre>
<h3 id="-">空函数</h3>
<p>[建议] 空函数不使用 <code>new Function()</code> 的形式。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var emptyFunction = function () {};
</code></pre>
<p>[建议] 对于性能有高要求的场合，建议存在一个空函数的常量，供多处使用共享。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var EMPTY_FUNCTION = function () {};

function MyClass() {
}

MyClass.prototype.abstractMethod = EMPTY_FUNCTION;
MyClass.prototype.hooks.before = EMPTY_FUNCTION;
MyClass.prototype.hooks.after = EMPTY_FUNCTION;
</code></pre>
<h2 id="-">面向对象</h2>
<p>[强制] 类的继承方案，实现时需要修正 <code>constructor</code>。</p>
<p>解释：</p>
<p>通常使用其他 library 的类继承方案都会进行 <code>constructor</code> 修正。如果是自己实现的类继承方案，需要进行 <code>constructor</code> 修正。</p>
<p>示例：</p>
<pre><code class="lang-javascript">/**
 * 构建类之间的继承关系
 *
 * @param {Function} subClass 子类函数
 * @param {Function} superClass 父类函数
 */
function inherits(subClass, superClass) {
    var F = new Function();
    F.prototype = superClass.prototype;
    subClass.prototype = new F();
    subClass.prototype.constructor = subClass;
}
</code></pre>
<p>[建议] 声明类时，保证 <code>constructor</code> 的正确性。</p>
<p>示例：</p>
<pre><code class="lang-javascript">function Animal(name) {
    this.name = name;
}

// 直接prototype等于对象时，需要修正constructor
Animal.prototype = {
    constructor: Animal,

    jump: function () {
        alert(&#39;animal &#39; + this.name + &#39; jump&#39;);
    }
};

// 这种方式扩展prototype则无需理会constructor
Animal.prototype.jump = function () {
    alert(&#39;animal &#39; + this.name + &#39; jump&#39;);
};
</code></pre>
<p>[建议] 属性在构造函数中声明，方法在原型中声明。</p>
<p>解释：</p>
<p>原型对象的成员被所有实例共享，能节约内存占用。所以编码时我们应该遵守这样的原则：原型对象包含程序不会修改的成员，如方法函数或配置项。</p>
<pre><code class="lang-javascript">function TextNode(value, engine) {
    this.value = value;
    this.engine = engine;
}

TextNode.prototype.clone = function () {
    return this;
};
</code></pre>
<p>[强制] 自定义事件的 <code>事件名</code> 必须全小写。</p>
<p>解释：</p>
<p>在 JavaScript 广泛应用的浏览器环境，绝大多数 DOM 事件名称都是全小写的。为了遵循大多数 JavaScript 开发者的习惯，在设计自定义事件时，事件名也应该全小写。</p>
<p>[强制] 自定义事件只能有一个 <code>event</code> 参数。如果事件需要传递较多信息，应仔细设计事件对象。</p>
<p>解释：</p>
<p>一个事件对象的好处有：</p>
<ol>
<li>顺序无关，避免事件监听者需要记忆参数顺序。</li>
<li>每个事件信息都可以根据需要提供或者不提供，更自由。</li>
<li>扩展方便，未来添加事件信息时，无需考虑会破坏监听器参数形式而无法向后兼容。</li>
</ol>
<p>[建议] 设计自定义事件时，应考虑禁止默认行为。</p>
<p>解释：</p>
<p>常见禁止默认行为的方式有两种：</p>
<ol>
<li>事件监听函数中 <code>return false</code>。</li>
<li>事件对象中包含禁止默认行为的方法，如 <code>preventDefault</code>。</li>
</ol>
<h2 id="-">动态特性</h2>
<h3 id="eval">eval</h3>
<p>[强制] 避免使用直接 <code>eval</code> 函数。</p>
<p>解释：</p>
<p>直接 <code>eval</code>，指的是以函数方式调用 <code>eval</code> 的调用方法。直接 <code>eval</code> 调用执行代码的作用域为本地作用域，应当避免。</p>
<p>如果有特殊情况需要使用直接 <code>eval</code>，需在代码中用详细的注释说明为何必须使用直接 <code>eval</code>，不能使用其它动态执行代码的方式，同时需要其他资深工程师进行 Code Review。</p>
<p>[建议] 尽量避免使用 <code>eval</code> 函数。</p>
<h3 id="-">动态执行代码</h3>
<p>[建议] 使用 <code>new Function</code> 执行动态代码。</p>
<p>解释：</p>
<p>通过 <code>new Function</code> 生成的函数作用域是全局使用域，不会影响当当前的本地作用域。如果有动态代码执行的需求，建议使用 <code>new Function</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">var handler = new Function(&#39;x&#39;, &#39;y&#39;, &#39;return x + y;&#39;);
var result = handler($(&#39;#x&#39;).val(), $(&#39;#y&#39;).val());
</code></pre>
<h3 id="with">with</h3>
<p>[建议] 尽量不要使用 <code>with</code>。</p>
<p>解释：</p>
<p>使用 <code>with</code> 可能会增加代码的复杂度，不利于阅读和管理；也会对性能有影响。大多数使用 <code>with</code> 的场景都能使用其他方式较好的替代。所以，尽量不要使用 <code>with</code>。</p>
<h3 id="delete">delete</h3>
<p>[建议] 减少 <code>delete</code> 的使用。</p>
<p>解释：</p>
<p>如果没有特别的需求，减少或避免使用 <code>delete</code>。<code>delete</code> 的使用会破坏部分 JavaScript 引擎的性能优化。</p>
<p>[建议] 处理 <code>delete</code> 可能产生的异常。</p>
<p>解释：</p>
<p>对于有被遍历需求，且值 <code>null</code> 被认为具有业务逻辑意义的值的对象，移除某个属性必须使用 <code>delete</code> 操作。</p>
<p>在严格模式或 IE 下使用 <code>delete</code> 时，不能被删除的属性会抛出异常，因此在不确定属性是否可以删除的情况下，建议添加 <code>try-catch</code> 块。</p>
<p>示例：</p>
<pre><code class="lang-javascript">try {
    delete o.x;
}
catch (deleteError) {
    o.x = null;
}
</code></pre>
<h3 id="-">对象属性</h3>
<p>[建议] 避免修改外部传入的对象。</p>
<p>解释：</p>
<p>JavaScript 因其脚本语言的动态特性，当一个对象未被 seal 或 freeze 时，可以任意添加、删除、修改属性值。</p>
<p>但是随意地对 非自身控制的对象 进行修改，很容易造成代码在不可预知的情况下出现问题。因此，设计良好的组件、函数应该避免对外部传入的对象的修改。</p>
<p>下面代码的 <strong>selectNode</strong> 方法修改了由外部传入的 <strong>datasource</strong> 对象。如果 <strong>datasource</strong> 用在其它场合（如另一个 Tree 实例）下，会造成状态的混乱。</p>
<pre><code class="lang-javascript">function Tree(datasource) {
    this.datasource = datasource;
}

Tree.prototype.selectNode = function (id) {
    // 从datasource中找出节点对象
    var node = this.findNode(id);
    if (node) {
        node.selected = true;
        this.flushView();
    }
};
</code></pre>
<p>对于此类场景，需要使用额外的对象来维护，使用由自身控制，不与外部产生任何交互的 <strong>selectedNodeIndex</strong> 对象来维护节点的选中状态，不对 <strong>datasource</strong> 作任何修改。</p>
<pre><code class="lang-javascript">function Tree(datasource) {
    this.datasource = datasource;
    this.selectedNodeIndex = {};
}

Tree.prototype.selectNode = function (id) {

    // 从datasource中找出节点对象
    var node = this.findNode(id);

    if (node) {
        this.selectedNodeIndex[id] = true;
        this.flushView();
    }

};
</code></pre>
<p>除此之外，也可以通过 deepClone 等手段将自身维护的对象与外部传入的分离，保证不会相互影响。</p>
<p>[建议] 具备强类型的设计。</p>
<p>解释：</p>
<ul>
<li>如果一个属性被设计为 <code>boolean</code> 类型，则不要使用 <code>1</code> 或 <code>0</code> 作为其值。对于标识性的属性，如对代码体积有严格要求，可以从一开始就设计为 <code>number</code> 类型且将 <code>0</code> 作为否定值。</li>
<li>从 DOM 中取出的值通常为 <code>string</code> 类型，如果有对象或函数的接收类型为 <code>number</code> 类型，提前作好转换，而不是期望对象、函数可以处理多类型的值。</li>
</ul>
<h1 id="-">浏览器环境</h1>
<h2 id="-">模块化</h2>
<h3 id="amd">AMD</h3>
<p>[强制] 使用 <code>AMD</code> 作为模块定义。</p>
<p>解释：</p>
<p>AMD 作为由社区认可的模块定义形式，提供多种重载提供灵活的使用方式，并且绝大多数优秀的 Library 都支持 AMD，适合作为规范。</p>
<p>目前，比较成熟的 AMD Loader 有：</p>
<ul>
<li>官方实现的 <a href="http://requirejs.org/">requirejs</a></li>
<li>百度自己实现的 <a href="https://github.com/ecomfe/esl">esl</a></li>
</ul>
<p>[强制] 模块 <code>id</code> 必须符合标准。</p>
<p>解释：</p>
<p>模块 id 必须符合以下约束条件：</p>
<ol>
<li>类型为 string，并且是由 <code>/</code> 分割的一系列 terms 来组成。例如：<code>this/is/a/module</code>。</li>
<li>term 应该符合 [a-zA-Z0-9_-]+ 规则。</li>
<li>不应该有 .js 后缀。</li>
<li>跟文件的路径保持一致。</li>
</ol>
<h3 id="define">define</h3>
<p>[建议] 定义模块时不要指明 <code>id</code> 和 <code>dependencies</code>。</p>
<p>解释：</p>
<p>在 AMD 的设计思想里，模块名称是和所在路径相关的，匿名的模块更利于封包和迁移。模块依赖应在模块定义内部通过 <code>local require</code> 引用。</p>
<p>所以，推荐使用 <code>define(factory)</code> 的形式进行模块定义。</p>
<p>示例：</p>
<pre><code class="lang-javascript">define(
    function (require) {
    }
);
</code></pre>
<p>[建议] 使用 <code>return</code> 来返回模块定义。</p>
<p>解释：</p>
<p>使用 return 可以减少 factory 接收的参数（不需要接收 exports 和 module），在没有 AMD Loader 的场景下也更容易进行简单的处理来伪造一个 Loader。</p>
<p>示例：</p>
<pre><code class="lang-javascript">define(
    function (require) {
        var exports = {};

        // ...

        return exports;
    }
);
</code></pre>
<h3 id="require">require</h3>
<p>[强制] 全局运行环境中，<code>require</code> 必须以 <code>async require</code> 形式调用。</p>
<p>解释：</p>
<p>模块的加载过程是异步的，同步调用并无法保证得到正确的结果。</p>
<p>示例：</p>
<pre><code class="lang-javascript">// good
require([&#39;foo&#39;], function (foo) {
});

// bad
var foo = require(&#39;foo&#39;);
</code></pre>
<p>[强制] 模块定义中只允许使用 <code>local require</code>，不允许使用 <code>global require</code>。</p>
<p>解释：</p>
<ol>
<li>在模块定义中使用 <code>global require</code>，对封装性是一种破坏。</li>
<li>在 AMD 里，<code>global require</code> 是可以被重命名的。并且 Loader 甚至没有全局的 <code>require</code> 变量，而是用 Loader 名称做为 <code>global require</code>。模块定义不应该依赖使用的 Loader。</li>
</ol>
<p>[强制] Package 在实现时，内部模块的 <code>require</code> 必须使用 <code>relative id</code>。</p>
<p>解释：</p>
<p>对于任何可能通过 发布-引入 的形式复用的第三方库、框架、包，开发者所定义的名称不代表使用者使用的名称。因此不要基于任何名称的假设。在实现源码中，<code>require</code> 自身的其它模块时使用 <code>relative id</code>。</p>
<p>示例：</p>
<pre><code class="lang-javascript">define(
    function (require) {
        var util = require(&#39;./util&#39;);
    }
);
</code></pre>
<p>[建议] 不会被调用的依赖模块，在 <code>factory</code> 开始处统一 <code>require</code>。</p>
<p>解释：</p>
<p>有些模块是依赖的模块，但不会在模块实现中被直接调用，最为典型的是 <code>css</code> / <code>js</code> / <code>tpl</code> 等 Plugin 所引入的外部内容。此类内容建议放在模块定义最开始处统一引用。</p>
<p>示例：</p>
<pre><code class="lang-javascript">define(
    function (require) {
        require(&#39;css!foo.css&#39;);
        require(&#39;tpl!bar.tpl.html&#39;);

        // ...
    }
);
</code></pre>
<h2 id="dom">DOM</h2>
<h3 id="-">元素获取</h3>
<p>[建议] 对于单个元素，尽可能使用 <code>document.getElementById</code> 获取，避免使用<code>document.all</code>。</p>
<p>[建议] 对于多个元素的集合，尽可能使用 <code>context.getElementsByTagName</code> 获取。其中 <code>context</code> 可以为 <code>document</code> 或其他元素。指定 <code>tagName</code> 参数为 <code>*</code> 可以获得所有子元素。</p>
<p>[建议] 遍历元素集合时，尽量缓存集合长度。如需多次操作同一集合，则应将集合转为数组。</p>
<p>解释：</p>
<p>原生获取元素集合的结果并不直接引用 DOM 元素，而是对索引进行读取，所以 DOM 结构的改变会实时反映到结果中。</p>
<p>示例：</p>
<pre><code class="lang-html">&lt;div&gt;&lt;/div&gt;
&lt;span&gt;&lt;/span&gt;

&lt;script&gt;
var elements = document.getElementsByTagName(&#39;*&#39;);

// 显示为 DIV
alert(elements[0].tagName);

var div = elements[0];
var p = document.createElement(&#39;p&#39;);
docpment.body.insertBefore(p, div);

// 显示为 P
alert(elements[0].tagName);
&lt;/script&gt;
</code></pre>
<p>[建议] 获取元素的直接子元素时使用 <code>children</code>。避免使用<code>childNodes</code>，除非预期是需要包含文本、注释和属性类型的节点。</p>
<h3 id="-">样式获取</h3>
<p>[建议] 获取元素实际样式信息时，应使用 <code>getComputedStyle</code> 或 <code>currentStyle</code>。</p>
<p>解释：</p>
<p>通过 style 只能获得内联定义或通过 JavaScript 直接设置的样式。通过 CSS class 设置的元素样式无法直接通过 style 获取。</p>
<h3 id="-">样式设置</h3>
<p>[建议] 尽可能通过为元素添加预定义的 className 来改变元素样式，避免直接操作 style 设置。</p>
<p>[强制] 通过 style 对象设置元素样式时，对于带单位非 0 值的属性，不允许省略单位。</p>
<p>解释：</p>
<p>除了 IE，标准浏览器会忽略不规范的属性值，导致兼容性问题。</p>
<h3 id="dom-">DOM 操作</h3>
<p>[建议] 操作 <code>DOM</code> 时，尽量减少页面 <code>reflow</code>。</p>
<p>解释：</p>
<p>页面 reflow 是非常耗时的行为，非常容易导致性能瓶颈。下面一些场景会触发浏览器的reflow：</p>
<ul>
<li>DOM元素的添加、修改（内容）、删除。</li>
<li>应用新的样式或者修改任何影响元素布局的属性。</li>
<li>Resize浏览器窗口、滚动页面。</li>
<li>读取元素的某些属性（offsetLeft、offsetTop、offsetHeight、offsetWidth、scrollTop/Left/Width/Height、clientTop/Left/Width/Height、getComputedStyle()、currentStyle(in IE)) 。</li>
</ul>
<p>[建议] 尽量减少 <code>DOM</code> 操作。</p>
<p>解释：</p>
<p>DOM 操作也是非常耗时的一种操作，减少 DOM 操作有助于提高性能。举一个简单的例子，构建一个列表。我们可以用两种方式：</p>
<ol>
<li>在循环体中 createElement 并 append 到父元素中。</li>
<li>在循环体中拼接 HTML 字符串，循环结束后写父元素的 innerHTML。</li>
</ol>
<p>第一种方法看起来比较标准，但是每次循环都会对 DOM 进行操作，性能极低。在这里推荐使用第二种方法。</p>
<h3 id="dom-">DOM 事件</h3>
<p>[建议] 优先使用 <code>addEventListener / attachEvent</code> 绑定事件，避免直接在 HTML 属性中或 DOM 的 <code>expando</code> 属性绑定事件处理。</p>
<p>解释：</p>
<p>expando 属性绑定事件容易导致互相覆盖。</p>
<p>[建议] 使用 <code>addEventListener</code> 时第三个参数使用 <code>false</code>。</p>
<p>解释：</p>
<p>标准浏览器中的 addEventListener 可以通过第三个参数指定两种时间触发模型：冒泡和捕获。而 IE 的 attachEvent 仅支持冒泡的事件触发。所以为了保持一致性，通常 addEventListener 的第三个参数都为 false。</p>
<p>[建议] 在没有事件自动管理的框架支持下，应持有监听器函数的引用，在适当时候（元素释放、页面卸载等）移除添加的监听器。</p>

			</article>
		</div>
	</div>
</body>

</html>
<script type="text/javascript" src="toc/js/jquery-1.4.4.min.js"></script>
<script type="text/javascript" src="toc/js/jquery.ztree.all-3.5.min.js"></script>
<script type="text/javascript" src="toc/js/ztree_toc.js"></script>
<script type="text/javascript" src="toc_conf.js"></script>
<script type="text/javascript" src="toc/js/prettify.js"></script>

<SCRIPT type="text/javascript">
	$(function() {
		var css_conf = eval(markdown_panel_style);
		$('#readme').css(css_conf)

		var conf = eval(jquery_ztree_toc_opts);
		$('#tree').ztree_toc(conf);
		$('pre').addClass('prettyprint linenums');
		$('td pre').removeClass('prettyprint');
		prettyPrint();

	});
</SCRIPT>